home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / OWLSRC.PAK / PREVWIN.CPP < prev    next >
C/C++ Source or Header  |  1997-05-06  |  12KB  |  414 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows
  3. // Copyright (c) 1995, 1997 by Borland International, All Rights Reserved
  4. //
  5. //$Revision:   10.8  $
  6. //
  7. // Implementation of TPreviewWin
  8. //----------------------------------------------------------------------------
  9. #include <owl/pch.h>
  10. #if !defined(OWL_PREVWIN_H)
  11. # include <owl/prevwin.h>
  12. #endif
  13. #if !defined(OWL_PREVWIN_RH)
  14. # include <owl/prevwin.rh>
  15. #endif
  16. #if !defined(OWL_EDITFILE_RH)
  17. # include <owl/editfile.rh>
  18. #endif
  19. #include <stdio.h>
  20.  
  21. OWL_DIAGINFO;
  22.  
  23. DEFINE_RESPONSE_TABLE1(TPreviewWin, TDecoratedFrame)
  24.   EV_COMMAND(IDB_PREVIOUS, CmPrevious),
  25.   EV_COMMAND_ENABLE(IDB_PREVIOUS, CePrevious),
  26.   EV_COMMAND(IDB_NEXT, CmNext),
  27.   EV_COMMAND_ENABLE(IDB_NEXT, CeNext),
  28.   EV_COMMAND(IDB_ONEUP, CmOneUp),
  29.   EV_COMMAND(IDB_TWOUP, CmTwoUp),
  30.   EV_COMMAND_ENABLE(IDB_TWOUP, CeTwoUp),
  31.   EV_COMMAND(IDB_DONE, CmDone),
  32. END_RESPONSE_TABLE;
  33.  
  34.  
  35. //
  36. // Constructor of a Preview frame window
  37. //
  38. TPreviewWin::TPreviewWin(TWindow *parentWindow,   /* Parent window object */
  39.                          TPrinter&  printer,      /* Printer object       */
  40.                          TPrintout& printout,     /* Printout object      */
  41.                          TWindow&   dataWindow,   /* Owner of preview data*/
  42.                          const char far* title,   /* Title of preview win */
  43.                          TLayoutWindow* client)   /* Client of preview win*/
  44. :
  45.   TDecoratedFrame(parentWindow, title, client),
  46.   DataWindow(dataWindow),
  47.   Printer(printer),
  48.   Printout(printout),
  49.   Client(client), 
  50.   Page1(0), Page2(0), PreviewSpeedBar(0), PrnDC(0)
  51. {
  52.   PRECONDITION(client != 0);
  53.   TPrintDialog::TData& data = Printer.GetSetup();
  54.  
  55.   // Retrieve device context of default printer
  56.   //
  57.   PrnDC = new TPrintDC(data.GetDriverName(),
  58.                        data.GetDeviceName(),
  59.                        data.GetOutputName(),
  60.                        data.GetDevMode());
  61.  
  62.   // Let printer object update it page sizes
  63.   //
  64.   Printer.SetPageSizes(*PrnDC);
  65.  
  66.   // Make a local copy of the printer's page size
  67.   //
  68.   PrinterPageSize = Printer.GetPageSize();
  69.  
  70.   // Set background of preview window
  71.   //
  72.   SetBkgndColor(TColor::SysAppWorkspace);
  73.  
  74.   // Setup toolbar of preview window
  75.   //
  76.   SetupSpeedBar();
  77.  
  78.   // 
  79.  
  80. #if 0
  81.   // We want a window that cannot be sized, maximized, or minimized.
  82.   //
  83.   Attr.Style = WS_VISIBLE | WS_POPUPWINDOW | WS_MINIMIZEBOX;
  84.  
  85. #else
  86.   Attr.X = 0;
  87.   Attr.Y = -1;
  88.   Attr.W = Parent->GetClientRect().Width();
  89.   Attr.H = Parent->GetClientRect().Height() + 1;
  90.   parentWindow->MapWindowPoints(Handle, (TPoint*)&Attr.X, 1);
  91. #endif
  92. }
  93.  
  94. //
  95. // Destructor of Preview frame window - Performs general cleanup
  96. //
  97. TPreviewWin::~TPreviewWin()
  98. {
  99.   delete Page1;
  100.   Page1 = 0;
  101.   delete Page2;
  102.   Page2 = 0;
  103.  
  104.   delete PrnDC;
  105.   PrnDC = 0;
  106. }
  107.  
  108. //
  109. // Creates a control bar which is inserted along the top edge of the
  110. // preview frame window.
  111. // NOTE: The control bar is populated with buttongadgets to iterate 
  112. //       through the pages and print the document.
  113. //
  114. void
  115. TPreviewWin::SetupSpeedBar()
  116. {
  117.   // Create default toolbar New and associate toolbar buttons with commands.
  118.   //
  119.   PreviewSpeedBar = new TControlBar(this);
  120.   PreviewSpeedBar->Insert(*new TButtonGadget(IDB_PREVIOUS, IDB_PREVIOUS, TButtonGadget::Command, true));
  121.   PreviewSpeedBar->Insert(*new TButtonGadget(IDB_NEXT, IDB_NEXT, TButtonGadget::Command, true));
  122.   PreviewSpeedBar->Insert(*new TSeparatorGadget(6));
  123.   PreviewSpeedBar->Insert(*new TButtonGadget(IDB_ONEUP, IDB_ONEUP, TButtonGadget::Exclusive, true, TButtonGadget::Down));
  124.   PreviewSpeedBar->Insert(*new TButtonGadget(IDB_TWOUP, IDB_TWOUP, TButtonGadget::Exclusive, true));
  125.   PreviewSpeedBar->Insert(*new TSeparatorGadget(12));
  126.   PreviewSpeedBar->Insert(*new TTextGadget(IDB_CURRPAGE, TGadget::Recessed, TTextGadget::Left, 10, "Page 1"));
  127.   PreviewSpeedBar->Insert(*new TSeparatorGadget(20));
  128.   PreviewSpeedBar->Insert(*new TButtonGadget(CM_FILEPRINT, CM_FILEPRINT, TButtonGadget::Command, true));
  129.   PreviewSpeedBar->Insert(*new TSeparatorGadget(20));
  130.   PreviewSpeedBar->Insert(*new TButtonGadget(IDB_DONE, IDB_DONE, TButtonGadget::Command, true));
  131.   Insert(*PreviewSpeedBar, TDecoratedFrame::Top);
  132. }
  133.  
  134. //
  135. // Overriden virtual of TWindow to allow preview frame to create the 
  136. // preview page(s)
  137. //
  138. void 
  139. TPreviewWin::SetupWindow()
  140. {
  141.   TDecoratedFrame::SetupWindow();
  142.  
  143.   //        SetPrintParams() before calling GetDialogInfo()
  144.   //        is the opposite of the order used by TPrinter::Print
  145.   //        (when we're really printing). However, the following
  146.   //        seems more logical since the 'Printout' can accurately
  147.   //        compute it page info. only after it has received the
  148.   //        PrinterDC... 
  149.   //        Investigate and make update so that a 'Printout' can
  150.   //        expect a consistent order of calls whether we're printing
  151.   //        or simply previewing...
  152.   //
  153.  
  154.   // Hand printout the target DC and page size
  155.   //
  156.   Printout.SetPrintParams(PrnDC, PrinterPageSize);
  157.  
  158.   // Allow printout to update page range information
  159.   //
  160.   TPrintDialog::TData& data = Printer.GetSetup();
  161.   Printout.GetDialogInfo(data.MinPage, data.MaxPage, 
  162.                          data.FromPage, data.ToPage);
  163.  
  164.   // Create/Initialize Preview Pages
  165.   //
  166.   Page1 = GetNewPreviewPage(Client, Printout, *PrnDC, PrinterPageSize, 
  167.                             data.FromPage > 0 ? data.FromPage : 1);
  168.   Page1->Create();
  169.   Page2 = 0;
  170.  
  171.   LayoutPages();
  172.  
  173. /*
  174.   data.FromPage = 1;
  175.   data.ToPage = 1;
  176.   data.MinPage = 1;
  177.   data.MaxPage = 1;
  178. */
  179. }
  180.  
  181. //
  182. // Returns a pointer to a TPreviewPage object. 
  183. // NOTE: This default version simply returns a 'true' TPreviewPage. 
  184. //       However, derived TPreviewWin-classes can return a more sophisticated
  185. //       preview page (for example, one that can handle zooming).
  186. //
  187. TPreviewPage* 
  188. TPreviewWin::GetNewPreviewPage(TWindow* parent, TPrintout& printout,
  189.                                TPrintDC&  prndc, TSize& printExtent,
  190.                                int pagenum)
  191. {
  192.   return new TPreviewPage(parent, printout, prndc, printExtent, pagenum);
  193. }
  194.  
  195. //
  196. // Repositions the preview page(s) using the aspect ration of the printer
  197. // when determining the dimensions of the pages.
  198. //
  199. void
  200. TPreviewWin::LayoutPages()
  201. {
  202.   TLayoutMetrics metrics1;
  203.  
  204.   metrics1.X.Set(lmLeft, lmRightOf, lmParent, lmLeft, 15);
  205.   metrics1.Y.Set(lmTop, lmBelow, lmParent, lmTop, 15);
  206.  
  207.   //
  208.   // Determine major axis of preview page, have that follow parent size.
  209.   // Make minor axis a percentage (aspect ratio) of the page's major axis
  210.   //
  211.   TRect r = Client->GetClientRect();
  212.   long ratio;
  213.  
  214.   if (PrinterPageSize.cx > PrinterPageSize.cy)
  215.     ratio = ((long)PrinterPageSize.cy * 100) / PrinterPageSize.cx;
  216.   else
  217.     ratio = ((long)PrinterPageSize.cx * 100) / PrinterPageSize.cy;
  218.  
  219.   bool xMajor = (((r.Width() * ratio) / 100) > r.Height());
  220.   if (xMajor) {
  221.     metrics1.Height.Set(lmBottom, lmAbove, lmParent, lmBottom, 15);
  222.     metrics1.Width.PercentOf(Page1, (int)((long)PrinterPageSize.cx * 95 / PrinterPageSize.cy), lmHeight);
  223.   }
  224.   else {
  225.     metrics1.Height.PercentOf(Page1, (int)((long)PrinterPageSize.cy * 95 / PrinterPageSize.cx), lmWidth);
  226.     metrics1.Width.Set(lmRight, lmLeftOf, lmParent, lmRight, 15);
  227.   }
  228.  
  229.   Client->SetChildLayoutMetrics(*Page1, metrics1);
  230.  
  231.   if (Page2) {
  232.     TLayoutMetrics metrics2;
  233.  
  234.     metrics2.X.Set(lmLeft, lmRightOf, Page1, lmRight, 30);
  235.     metrics2.Y.SameAs(Page1, lmTop);
  236.  
  237.     // Assume portrait
  238.     //
  239.     metrics2.Width.SameAs(Page1, lmWidth);
  240.     metrics2.Height.SameAs(Page1, lmBottom);
  241.  
  242.     Client->SetChildLayoutMetrics(*Page2, metrics2);
  243.   }
  244.  
  245.   Client->Layout();
  246. }
  247.  
  248. //
  249. // Update the information displayed on the control bar of the 
  250. // preview frame window.
  251. // NOTE: This method simply updates the page info. Derived classes
  252. //       can display additional information.
  253. //
  254. void 
  255. TPreviewWin::UpdateSpeedBar()
  256. {
  257.   // Update the page count.
  258.   //
  259.   TTextGadget* pgGadget = TYPESAFE_DOWNCAST(
  260.                                  PreviewSpeedBar->GadgetWithId(IDB_CURRPAGE), 
  261.                                  TTextGadget);
  262.   if (pgGadget) {
  263.     char buffer[32];
  264.     if (Page2 && Page2->GetPageNumber())
  265.       sprintf(buffer, "Page %d - %d", Page1->GetPageNumber(),
  266.                                       Page2->GetPageNumber());
  267.     else
  268.       sprintf(buffer, "Page %d", Page1->GetPageNumber());
  269.     pgGadget->SetText(buffer);
  270.   }
  271. }
  272.  
  273. //
  274. // Command enabler of 'PREVIOUS' command
  275. //
  276. void 
  277. TPreviewWin::CePrevious(TCommandEnabler& ce)
  278. {
  279.   // Only have previous on if we're not at the first page.
  280.   //
  281.   ce.Enable(Page1->GetPageNumber() > 1);
  282. }
  283.  
  284. //
  285. // Command enabler of 'NEXT' command.
  286. //
  287. void 
  288. TPreviewWin::CeNext (TCommandEnabler& ce)
  289. {
  290.   // Only have next on if we're not at the last page.
  291.   //
  292.   TPrintDialog::TData &printerData = Printer.GetSetup();
  293.   ce.Enable(printerData.ToPage < printerData.MaxPage);
  294. }
  295.  
  296. //
  297. // Handler of 'PREVIOUS' command
  298. //
  299. void 
  300. TPreviewWin::CmPrevious()
  301. {
  302.   TPrintDialog::TData &printerData = Printer.GetSetup();
  303.  
  304.   if (printerData.FromPage > printerData.MinPage) { 
  305.     printerData.FromPage--;
  306.     printerData.ToPage--;
  307.  
  308.     Page1->SetPageNumber(printerData.FromPage);
  309.     if (Page2)
  310.       Page2->SetPageNumber(printerData.ToPage);
  311.   }
  312.  
  313.   UpdateSpeedBar();
  314. }
  315.  
  316. //
  317. // Handler of 'NEXT' command
  318. //
  319. void 
  320. TPreviewWin::CmNext()
  321. {
  322.   TPrintDialog::TData &printerData = Printer.GetSetup();
  323.  
  324.   if (printerData.ToPage < printerData.MaxPage) {
  325.     printerData.FromPage++;
  326.     printerData.ToPage++;
  327.  
  328.     Page1->SetPageNumber(printerData.FromPage);
  329.     if (Page2)
  330.       Page2->SetPageNumber(printerData.ToPage);
  331.   }
  332.   UpdateSpeedBar();
  333. }
  334.  
  335. //
  336. // Handler of request for only one preview page.
  337. //
  338. void 
  339. TPreviewWin::CmOneUp ()
  340. {
  341.   if (Page2) {
  342.     Client->RemoveChildLayoutMetrics(*Page2);
  343.  
  344.     delete Page2;
  345.     Page2 = 0;
  346.  
  347.     Client->Layout();
  348.  
  349.     TPrintDialog::TData &printerData = Printer.GetSetup();
  350.     printerData.ToPage = printerData.FromPage;
  351.  
  352.     UpdateSpeedBar();
  353.   }
  354. }
  355.  
  356. //
  357. // Command enabler of request for two preview pages.
  358. //
  359. void 
  360. TPreviewWin::CeTwoUp(TCommandEnabler& ce)
  361. {
  362.   // Two up is only available for portrait mode.
  363.   //
  364.   ce.Enable(PrinterPageSize.cx <= PrinterPageSize.cy);
  365. }
  366.  
  367. //
  368. // Handler of request for two preview pages
  369. //
  370. void 
  371. TPreviewWin::CmTwoUp()
  372. {
  373.   if (Page2 == 0) {
  374.     Page2 = GetNewPreviewPage(Client, Printout, *PrnDC, 
  375.                               PrinterPageSize, 
  376.                               Page1->GetPageNumber() + 1);
  377.     Page2->Create();
  378.  
  379.     TPrintDialog::TData &printerData = Printer.GetSetup();
  380.  
  381.     // Page 2 is the next page.  If the next page is outside of our range then
  382.     // set the first page back one and the 2nd page is the current page.  If
  383.     // the document is only 1 page long then the 2nd page is empty.
  384.     //
  385.     if (printerData.FromPage == printerData.MaxPage) {
  386.       if (printerData.FromPage > 1) {
  387.         printerData.FromPage--;
  388.         printerData.ToPage = printerData.FromPage + 1;
  389.         Page1->SetPageNumber(printerData.FromPage);
  390.         Page2->SetPageNumber(printerData.ToPage);
  391.       } 
  392.       else {
  393.         Page2->SetPageNumber(0);
  394.       }
  395.     } 
  396.     else {
  397.       printerData.ToPage = printerData.FromPage + 1;
  398.       Page2->SetPageNumber(printerData.ToPage);
  399.     }
  400.  
  401.     LayoutPages();
  402.     UpdateSpeedBar();
  403.   }
  404. }
  405.  
  406. //
  407. // Handler of request to terminate preview session
  408. //
  409. void 
  410. TPreviewWin::CmDone()
  411. {
  412.   CloseWindow();
  413. }
  414.